"""
面向对象：
    1. 基础概念：
        1. 类：具有相同属性和方法的对象的集合。
        2. 对象：类的实例。
        3. 类的属性：类的特征。
        4. 类的方法：类的行为。
    2. 封装：
        1. 封装：将数据和方法封装在一个类中，对外提供接口，隐藏内部实现细节。
        2. 私有属性：在属性名前面加上两个下划线，只能在类的内部访问。
        3. 私有方法：在方法名前面加上两个下划线，只能在类的内部访问。
        4. 公有属性：在属性名前面没有下划线，在类的内部和外部都可以访问。
        5. 公有方法：在方法名前面没有下划线，在类的内部和外部都可以访问。
        6. 封装的优点：
            1. 提高代码的可读性。
            2. 提高代码的可维护性。
            3. 提高代码的安全性。
    3. 继承：
        1. 继承：子类继承父类的属性和方法。
        2. 继承的语法：class 子类(父类):
        3. 继承的优点：
            1. 提高代码的复用性。
            2. 提高代码的可维护性。
            3. 提高代码的扩展性。
        4. 继承的缺点：
            1. 继承的层次过深，会导致代码的可读性变差。
            2. 继承的层次过深，会导致代码的可维护性变差。
            3. 继承的层次过深，会导致代码的扩展性变差。
        5. 继承的注意事项：
            1. 子类可以重写父类的方法。
            2. 子类可以调用父类的方法。
            3. 子类可以调用父类的属性。
            4. 子类可以调用父类的构造方法。
            5. 子类可以调用父类的析构方法。
            6. 子类可以调用父类的私有方法。
    4. 多继承：
        1. 多继承：子类继承多个父类的属性和方法。
        2. 多继承的语法：class 子类(父类1, 父类2, ...):
        3. 多继承的优点：
            1. 提高代码的复用性。
            2. 提高代码的可维护性。
            3. 提高代码的扩展性。
        4. 多继承的缺点：
            1. 多继承的层次过深，会导致代码的可读性变差。
            2. 多继承的层次过深，会导致代码的可维护性变差。
            3. 多继承的层次过深，会导致代码的扩展性变差。
        5. 多继承的注意事项：
            1. 子类可以重写父类的方法。
            2. 子类可以调用父类的方法。
            3. 子类可以调用父类的属性。
            4. 子类可以调用父类的构造方法。
            5. 子类可以调用父类的析构方法。
    5. 多态：
        1. 多态：同一个方法可以根据对象的不同类型调用不同的方法。
        2. 多态的语法：
            1. 定义一个父类，定义一个子类，子类继承父类。
            2. 定义一个方法，方法的参数是父类的对象。
            3. 在方法中调用父类的方法。
            4. 在方法中调用子类的方法。
        3. 多态的优点：
            1. 提高代码的可读性。
            2. 提高代码的可维护性。
            3. 提高代码的扩展性。
        4. 多态的缺点：
            1. 多态的层次过深，会导致代码的可读性变差。
            2. 多态的层次过深，会导致代码的可维护性变差。
            3. 多态的层次过深，会导致代码的扩展性变差。
"""
#  封装案例：
class Person:
    def __init__(self, name, age):
        self.__name = name
        self.__age = age
    def get_name(self):
        return self.__name
    def get_age(self):
        return self.__age
    def set_name(self, name):
        self.__name = name
    def set_age(self, age):
        self.__age = age
# 继承案例：
class Student(Person):
    def __init__(self, name, age, score):
        super().__init__(name, age)
        self.__score = score
    def get_score(self):
        return self.__score
    def set_score(self, score):
        self.__score = score
# 多态案例：
class Teacher(Person):
    def __init__(self, name, age, salary):
        super().__init__(name, age)
        self.__salary = salary
    def get_salary(self):
        return self.__salary
    def set_salary(self, salary):
        self.__salary = salary
    def work(self):
        print("Teacher is working...")
